#include "stdafx.h"
#include "CFxCallbacks.h"

#include "XamlPropertyToken.h"
#include "XamlTypeToken.h"

#include "XamlTypeNamespaceToken.h"



CFxCallbacks::CFxCallbacks(void)
{
	this->m_pfnDependencyObject_EnterImpl = NULL;
	this->m_pfnDependencyObject_LeaveImpl = NULL;
	this->m_pfnDependencyObject_SetPeerReferenceToProperty = NULL;
	this->m_pfnDependencyObject_GetManagedReference = NULL;
	this->m_pfnDependencyObject_StoreManagedReferenceToValue = NULL;
	this->m_pfnDependencyObject_AddPeerReferenceToItem = NULL;
	this->m_pfnDependencyObject_RemovePeerReferenceToItem = NULL;
	this->m_pfnUIElement_OnCreateAutomationPeer = NULL;
	this->m_pfnUIElement_SetIsUnloadingFlag = NULL;
	this->m_pfnUIElement_GetCanManipulateElements = NULL;
	this->m_pfnUIElement_SetManipulationHandler = NULL;
	this->m_pfnUIElement_SetManipulationHandlerWantsNotifications = NULL;
	this->m_pfnUIElement_GetManipulatedElement = NULL;
	this->m_pfnUIElement_GetManipulationViewport = NULL;
	this->m_pfnUIElement_GetManipulationPrimaryContent = NULL;
	this->m_pfnUIElement_GetManipulationPrimaryContentTransform = NULL;
	this->m_pfnUIElement_GetManipulationSnapPoints = NULL;
	this->m_pfnUIElement_NotifyManipulatabilityAffectingPropertyChanged = NULL;
	this->m_pfnUIElement_NotifyContentAlignmentAffectingPropertyChanged = NULL;
	this->m_pfnUIElement_NotifyManipulationProgress = NULL;
	this->m_pfnUIElement_NotifySnapPointsChanged = NULL;
	this->m_pfnUIElement_OnDirectManipulationCrossSlideContainerStart = NULL;
	this->m_pfnUIElement_NotifyInputPaneStateChange = NULL;
	this->m_pfnUIElement_ApplyInputPaneTransition = NULL;
	this->m_pfnUIElement_SetRootScrollViewer = NULL;
	this->m_pfnUIElement_IsScrollViewer = NULL;
	this->m_pfnUIElement_RootScrollViewerForceUpdateClip = NULL;
	this->m_pfnFrameworkElement_MeasureOverride = NULL;
	this->m_pfnFrameworkElement_ArrangeOverride = NULL;
	this->m_pfnFrameworkElement_OnApplyTemplate = NULL;
	this->m_pfnControl_GetBuiltInStyle = NULL;
	this->m_pfnContentControl_ShouldBringIntoViewOnKeyboardFocus = NULL;
	this->m_pfnWindow_FireClosingEvent = NULL;
	this->m_pfnEasingFunctionBase_EaseManaged = NULL;
	this->m_pfnMediaElement_AcquireLicenseAbort = NULL;
	this->m_pfnMediaElement_AcquireLicenseBegin = NULL;
	this->m_pfnTextBox_EnableScrollViewerIntegration = NULL;
	this->m_pfnTextBox_SetScrollOffsetOnScrollViewer = NULL;
	this->m_pfnTextBox_GetViewportSize = NULL;
	this->m_pfnTextBox_TextWrappingChanged = NULL;
	this->m_pfnTextBox_InvalidateScrollInfo = NULL;
	this->m_pfnTextBox_AttachDeleteButtonClickHandler = NULL;
	this->m_pfnRichTextBox_EnableScrollViewerIntegration = NULL;
	this->m_pfnRichTextBox_GetViewportSize = NULL;
	this->m_pfnRichTextBox_TextWrappingChanged = NULL;
	this->m_pfnRichTextBox_ClipboardElement = NULL;
	this->m_pfnRichTextBox_ClipboardString = NULL;
	this->m_pfnRichTextBox_ClipboardEnd = NULL;
	this->m_pfnRichEditBox_HandleHyperlinkNavigation = NULL;
	this->m_pfnTextBoxView_CaretChanged = NULL;
	this->m_pfnTextBoxView_CaretVisibilityChanged = NULL;
	this->m_pfnTextBoxView_InvalidateView = NULL;
	this->m_pfnPasswordBox_AttachRevealButtonListener = NULL;
	this->m_pfnItemsControl_SetItemCollection = NULL;
	this->m_pfnItemsControl_ClearVisualChildren = NULL;
	this->m_pfnItemsControl_DisplayMemberPathChanged = NULL;
	this->m_pfnItemsControl_RecreateVisualChildren = NULL;
	this->m_pfnItemsControl_NotifyAllItemsAdded = NULL;
	this->m_pfnItemsPresenter_Dispose = NULL;
	this->m_pfnContentControl_OnContentChanged = NULL;
	this->m_pfnContentPresenter_GetContentType = NULL;
	this->m_pfnDisplayMemberTemplate_BindText = NULL;
	this->m_pfnPopup_AddManagedPeerReference = NULL;
	this->m_pfnPopup_RemoveManagedPeerReference = NULL;
	this->m_pfnEffect_MapRect = NULL;
	this->m_pfnEffect_MapRectInverse = NULL;
	this->m_pfnEffect_GetEffectMapping = NULL;
	this->m_pfnEffect_MapPoint = NULL;
	this->m_pfnEffect_MapPointInverse = NULL;
	this->m_pfnJoltHelper_FireEvent = NULL;
	this->m_pfnJoltHelper_RaiseEvent = NULL;
	this->m_pfnJoltHelper_PopulateDragEventArgs = NULL;
	this->m_pfnJoltHelper_GetResourceFromAssembly = NULL;
	this->m_pfnJoltHelper_TriggerGCCollect = NULL;
	this->m_pfnJoltHelper_LoadAssemblyFromFilePath = NULL;
	this->m_pfnJoltHelper_LoadAssembly = NULL;
	this->m_pfnJoltHelper_SetCulture = NULL;
	this->m_pfnError_ClearException = NULL;
	this->m_pfnError_GetExceptionText = NULL;
	this->m_pfnError_CallAUEHandler = NULL;
	this->m_pfnFrameworkCallbacks_CreateUnknownObject = NULL;
	this->m_pfnFrameworkCallbacks_CreateKnownObject = NULL;
	this->m_pfnFrameworkCallbacks_CreateWrapperObject = NULL;
	this->m_pfnFrameworkCallbacks_InvalidateProperty = NULL;
	this->m_pfnFrameworkCallbacks_SetPropertyAttribute = NULL;
	this->m_pfnFrameworkCallbacks_SetEventAttribute = NULL;
	this->m_pfnFrameworkCallbacks_SetBindingForObject = NULL;
	this->m_pfnFrameworkCallbacks_InvalidateStyleBinding = NULL;
	this->m_pfnFrameworkCallbacks_SetRelativeSource = NULL;
	this->m_pfnFrameworkCallbacks_SetTemplateBinding = NULL;
	this->m_pfnFrameworkCallbacks_ResolveTypeName = NULL;
	this->m_pfnFrameworkCallbacks_EnsureIsObjectOfType = NULL;
	this->m_pfnFrameworkCallbacks_TypeIsAssignableFrom = NULL;
	this->m_pfnFrameworkCallbacks_GetCustomTypeIDFromObject = NULL;
	this->m_pfnFrameworkCallbacks_GetCustomTypeFullName = NULL;
	this->m_pfnFrameworkCallbacks_AreObjectsOfSameType = NULL;
	this->m_pfnFrameworkCallbacks_GetBaseType = NULL;
	this->m_pfnFrameworkCallbacks_GetCustomPropertyID = NULL;
	this->m_pfnFrameworkCallbacks_SetCustomProperty = NULL;
	this->m_pfnFrameworkCallbacks_HasManagedNameProperty = NULL;
	this->m_pfnFrameworkCallbacks_GetCustomProperty = NULL;
	this->m_pfnFrameworkCallbacks_GetCustomPropertyType = NULL;
	this->m_pfnFrameworkCallbacks_SetAnimatedValue = NULL;
	this->m_pfnFrameworkCallbacks_ClearAnimatedValue = NULL;
	this->m_pfnFrameworkCallbacks_SetDataContext = NULL;
	this->m_pfnFrameworkCallbacks_ClearDataContext = NULL;
	this->m_pfnFrameworkCallbacks_SetContent = NULL;
	this->m_pfnFrameworkCallbacks_CreateBindingExtension = NULL;
	this->m_pfnFrameworkCallbacks_GetTypeFlags = NULL;
	this->m_pfnFrameworkCallbacks_SupportInitializeEndInit = NULL;
	this->m_pfnFrameworkCallbacks_GetRootAssemblyName = NULL;
	this->m_pfnFrameworkCallbacks_CheckPeerType = NULL;
	this->m_pfnFrameworkCallbacks_ManagedPeerTreeUpdate = NULL;
	this->m_pfnFrameworkCallbacks_CreateManagedPeer = NULL;
	this->m_pfnFrameworkCallbacks_UnpegManagedPeerNoRef = NULL;
	this->m_pfnFrameworkCallbacks_PegManagedPeerNoRef = NULL;
	this->m_pfnFrameworkCallbacks_ShutdownAllPeers = NULL;
	this->m_pfnFrameworkCallbacks_SetTemplateEventRoot = NULL;
	this->m_pfnFrameworkCallbacks_GetTemplateEventRoot = NULL;
	this->m_pfnFrameworkCallbacks_ProcessMarkupExtension = NULL;
	this->m_pfnFrameworkCallbacks_IsCustomEvent = NULL;
	this->m_pfnFrameworkCallbacks_IsoStorageIncreaseQuotaTo = NULL;
	this->m_pfnFrameworkCallbacks_NavigationHelper_Navigate = NULL;
	this->m_pfnFrameworkCallbacks_Hyperlink_OnClick = NULL;
	this->m_pfnFrameworkCallbacks_IsWellFormedUriString = NULL;
	this->m_pfnFrameworkCallbacks_GetCollectionForDependencyObjectCollection = NULL;
	this->m_pfnFrameworkCallbacks_ResolveFileResource = NULL;
	this->m_pfnFrameworkCallbacks_LoadThemeResources = NULL;
	this->m_pfnInternalWebRequest_WebRequest_CompletedCallback = NULL;
	this->m_pfnInternalWebRequest_WebRequest_FailedCallback = NULL;
	this->m_pfnInternalWebRequest_WebRequest_ProgressCallback = NULL;
	this->m_pfnInternalWebRequest_WebRequest_UploadProgressCallback = NULL;
	this->m_pfnManagedPeerTable_TryPegManagedPeer = NULL;
	this->m_pfnManagedPeerTable_TryUnpegManagedPeer = NULL;
	this->m_pfnFrameworkCallbacks_ProcessTabStop = NULL;
	this->m_pfnFrameworkCallbacks_GetFirstFocusableElement = NULL;
	this->m_pfnFrameworkCallbacks_GetLastFocusableElement = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_Initialize = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_ResolveAssembly = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTypeNamespace = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTypeNamespaceForType = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_LookupTypeFlags = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_LookupPropertyFlags = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_ResolveTypeName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_ResolvePropertyName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_ResolveDependencyPropertyName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTypeName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTypeFullName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetPropertyName = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetBaseType = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetDeclaringType = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_IsAssignableFrom = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetContentProperty = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetCollectionItemType = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTextSyntaxForType = NULL;
	this->m_pfnManagedTypeInfoProviderRPInvokes_GetTextSyntaxForProperty = NULL;
	this->m_pfnHwndHost_BuildWindow = NULL;
	this->m_pfnHwndHost_DestroyWindow = NULL;
	this->m_pfnHwndHost_TranslateAccelerator = NULL;
	this->m_pfnXcpImports_ParticipateInTransition = NULL;
	this->m_pfnXcpImports_CreateStoryboardsForTransition = NULL;
	this->m_pfnXcpImports_StaggerManaged = NULL;
	this->m_pfnXcpImports_GetDynamicTimelines = NULL;
	this->m_pfnXcpImports_PerFrameCallback = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerStringValue = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerIntValue = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerPointValue = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerRectValue = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerAPValue = NULL;
	this->m_pfnAutomationPeer_CallAutomationPeerMethod = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerChildren = NULL;
	this->m_pfnAutomationPeer_GetAutomationPeerAPValueFromPoint = NULL;
	this->m_pfnAutomationPeer_GetPattern = NULL;
	this->m_pfnAutomationPeer_UIATextRangeInvoke = NULL;
	this->m_pfnAutomationPeer_UIAPatternInvoke = NULL;
	this->m_pfnAutomationPeer_NotifyNoUIAClientObjectForAP = NULL;
	this->m_pfnAutomationPeer_GenerateAutomationPeerEventsSource = NULL;
	this->m_pfnItemContainerGenerator_ExecuteDeferredUnlink = NULL;
	this->m_pfnVisualStates_ChangeControlVisualState = NULL;
	this->m_pfnLicenseAcquirer_AbortComplete = NULL;
	this->m_pfnLicenseAcquirer_DomainJoinRequired = NULL;
	this->m_pfnLicenseAcquirer_Complete = NULL;
	this->m_pfnLicenseAcquirer_ChallengeGenerated = NULL;
	this->m_pfnMediaStreamSource_OpenMedia = NULL;
	this->m_pfnMediaStreamSource_CloseMedia = NULL;
	this->m_pfnMediaStreamSource_Seek = NULL;
	this->m_pfnMediaStreamSource_GetSample = NULL;
	this->m_pfnMediaStreamSource_SetPlaybackRate = NULL;
	this->m_pfnMediaStreamSource_GetDiagnostic = NULL;
	this->m_pfnMediaStreamSource_SwitchMediaStream = NULL;
	this->m_pfnMediaStreamSource_GetAudioBufferLength = NULL;
	this->m_pfnMediaStreamSource_DrmSetupDecryptorCompleted = NULL;
	this->m_pfnMediaStreamSource_DrmDecryptorInvalidated = NULL;
	this->m_pfnDomainAcquirer_AbortComplete = NULL;
	this->m_pfnDomainAcquirer_ChallengeGenerated = NULL;
	this->m_pfnDomainAcquirer_Complete = NULL;
	this->m_pfnMultiScaleTileSource_GetTileLayerData = NULL;
	this->m_pfnMultiScaleTileSource_GetTileLayerCount = NULL;
	this->m_pfnMultiScaleTileSource_GetMSITileSourceInitParams = NULL;
	this->m_pfnMultiScaleTileSource_GetMaxTileBlendTime = NULL;
	this->m_pfnResourceDictionary_UpdateResource = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_CreateInstance = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_CreateFromValue = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_CreateFromXmlText = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_GetValue = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_SetValue = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_Add = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_AddToDictionary = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_CallProvideValue = NULL;
	this->m_pfnXamlManagedRuntimeRPInvokes_SetConnectionId = NULL;
	this->m_pfnXamlSchemaContext_EnsureManagedAssemblyAttributesLoaded = NULL;
	this->m_pfnApplicationBarService_GetBottomAppBarStatus = NULL;
	this->m_pfnApplicationBarService_ProcessToggleApplicationBarsFromMouseRightTapped = NULL;
	this->m_pfnWindow_GetCoreWindowBounds = NULL;
}

HRESULT CFxCallbacks::DependencyObject_EnterImpl( CDependencyObject * nativeDO, CDependencyObject * nativeNamescopeOwner, XUINT32 bLive, XUINT32 bSkipNameRegistration, XUINT32 bCoercedIsEnabled, XUINT32 bUseLayoutRounding )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_EnterImpl()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_LeaveImpl( CDependencyObject * nativeDO, CDependencyObject * nativeNamescopeOwner, XUINT32 bLive, XUINT32 bSkipNameRegistration, XUINT32 bCoercedIsEnabled, XUINT32 bVisualTreeBeingReset )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_LeaveImpl()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_SetPeerReferenceToProperty( CDependencyObject * nativeTarget, XUINT32 nPropertyID, CDependencyObject * nativeValue, XUINT32 fPreservePegNoRef )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_SetPeerReferenceToProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_GetManagedReference( CDependencyObject * nativeObject, XUINT32 nPropertyID, CDependencyObject * * nativeValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_GetManagedReference()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_StoreManagedReferenceToValue( CDependencyObject * nativeObject, XUINT32 nPropertyID, CValue * wrappedValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_StoreManagedReferenceToValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_AddPeerReferenceToItem( CDependencyObject * nativeOwner, CDependencyObject * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_AddPeerReferenceToItem()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DependencyObject_RemovePeerReferenceToItem( CDependencyObject * nativeOwner, CDependencyObject * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDependencyObject_RemovePeerReferenceToItem()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_OnCreateAutomationPeer( CDependencyObject * nativeTarget, CAutomationPeer * * returnAP )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_OnCreateAutomationPeer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_SetIsUnloadingFlag( CUIElement * nativeTarget, XUINT32 fIsUnloading )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_SetIsUnloadingFlag()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetCanManipulateElements( CUIElement * nativeTarget, XUINT32 * fCanManipulateElementsByTouch, XUINT32 * fCanManipulateElementsNonTouch )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetCanManipulateElements()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_SetManipulationHandler( CUIElement * nativeTarget, void * nativeManipulationHandler )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_SetManipulationHandler()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_SetManipulationHandlerWantsNotifications( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, XUINT32 fWantsNotifications )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_SetManipulationHandlerWantsNotifications()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetManipulatedElement( CUIElement * nativeTarget, CDependencyObject * nativePointedElement, CUIElement * nativeChildElement, CUIElement * * nativeManipulatedElement )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetManipulatedElement()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetManipulationViewport( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, struct XRECTF_WH * pBounds, CMILMatrix * pInputTransform, XUINT32 * pTouchConfiguration, XUINT32 * pNonTouchConfiguration, XUINT32 * pBringIntoViewportConfiguration, XUINT8 * pcConfigurations, XUINT32 * * ppConfigurations, XUINT32 * pChainedMotionTypes )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetManipulationViewport()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetManipulationPrimaryContent( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, struct XRECTF_WH * pBounds, XUINT32 * pHorizontalAlignment, XUINT32 * pVerticalAlignment, XFLOAT * pMinZoomFactor, XFLOAT * pMaxZoomFactor, XUINT32 * pfIsLayoutRefreshed )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetManipulationPrimaryContent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetManipulationPrimaryContentTransform( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, XUINT32 fInManipulation, XUINT32 fForInitialTransformationAdjustment, XUINT32 pfIsZoomFactorStatic, XUINT32 * , XFLOAT * pTranslationX, XFLOAT * pTranslationY, XFLOAT * pZoomFactor )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetManipulationPrimaryContentTransform()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_GetManipulationSnapPoints( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, XUINT32 motionType, XUINT32 * pfAreSnapPointsOptional, XUINT32 * pfAreSnapPointsSingle, XUINT32 * pfAreSnapPointsRegular, XFLOAT * pRegularOffset, XFLOAT * pRegularInterval, XUINT32 * pcIrregularSnapPoints, XFLOAT * * ppIrregularSnapPoints, XUINT32 * pSnapCoordinate )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_GetManipulationSnapPoints()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_NotifyManipulatabilityAffectingPropertyChanged( CUIElement * nativeTarget, XUINT32 fIsInLiveTree )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_NotifyManipulatabilityAffectingPropertyChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_NotifyContentAlignmentAffectingPropertyChanged( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, XUINT32 fIsForHorizontalAlignment )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_NotifyContentAlignmentAffectingPropertyChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_NotifyManipulationProgress( CUIElement * nativeTarget, CUIElement * nativeManipulatedElement, XUINT32 state, XFLOAT xCumulativeTranslation, XFLOAT yCumulativeTranslation, XFLOAT zCumulativeFactor, XFLOAT xCenter, XFLOAT yCenter, XUINT32 fIsInertial, XUINT32 fIsTouchConfigurationActivated, XUINT32 fIsBringIntoViewportConfigurationActivated )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_NotifyManipulationProgress()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_NotifySnapPointsChanged( CUIElement * nativeTarget, XUINT32 fHorizontalSnapPoints )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_NotifySnapPointsChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_OnDirectManipulationCrossSlideContainerStart( CUIElement * nativeTarget, XUINT32 parentViewportConfiguration, XUINT32 parentViewportsCombinedConfigurations, XUINT32 * pfStarted )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_OnDirectManipulationCrossSlideContainerStart()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_NotifyInputPaneStateChange( CUIElement * nativeTarget, XUINT32 fInputPaneShow )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_NotifyInputPaneStateChange()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_ApplyInputPaneTransition( CUIElement * nativeTarget, XUINT32 fEnableThemeTransition )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_ApplyInputPaneTransition()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_SetRootScrollViewer( CUIElement * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_SetRootScrollViewer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_IsScrollViewer( CUIElement * nativeTarget, XUINT32 * pIsScrollViewer )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_IsScrollViewer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::UIElement_RootScrollViewerForceUpdateClip( CUIElement * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasUIElement_RootScrollViewerForceUpdateClip()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkElement_MeasureOverride( CFrameworkElement * nativeTarget, XFLOAT inWidth, XFLOAT inHeight, XFLOAT * outWidth, XFLOAT * outHeight )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkElement_MeasureOverride()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkElement_ArrangeOverride( CFrameworkElement * nativeTarget, XFLOAT inWidth, XFLOAT inHeight, XFLOAT * outWidth, XFLOAT * outHeight )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkElement_ArrangeOverride()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkElement_OnApplyTemplate( CFrameworkElement * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkElement_OnApplyTemplate()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Control_GetBuiltInStyle( CDependencyObject * nativeTarget, CStyle * * nativeStyle )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasControl_GetBuiltInStyle()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ContentControl_ShouldBringIntoViewOnKeyboardFocus( CDependencyObject * nativeTarget, XUINT32 * pShouldBringIntoView )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasContentControl_ShouldBringIntoViewOnKeyboardFocus()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Window_FireClosingEvent( CDependencyObject *, XUINT32, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasWindow_FireClosingEvent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::EasingFunctionBase_EaseManaged( CDependencyObject * nativeTarget, XFLOAT * alpha, XFLOAT normalizedTime )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEasingFunctionBase_EaseManaged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaElement_AcquireLicenseAbort( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaElement_AcquireLicenseAbort()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaElement_AcquireLicenseBegin( void *, struct IPALMemory *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaElement_AcquireLicenseBegin()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_EnableScrollViewerIntegration( CDependencyObject *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_EnableScrollViewerIntegration()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_SetScrollOffsetOnScrollViewer( CDependencyObject *, XFLOAT, XFLOAT )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_SetScrollOffsetOnScrollViewer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_GetViewportSize( CDependencyObject *, XFLOAT *, XFLOAT * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_GetViewportSize()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_TextWrappingChanged( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_TextWrappingChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_InvalidateScrollInfo( CDependencyObject * nativeTextBoxView )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_InvalidateScrollInfo()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ProcessTabStop( CDependencyObject *, XUINT32, CDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasFrameworkCallbacks_ProcessTabStop()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetFirstFocusableElement( CDependencyObject *, CDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasFrameworkCallbacks_GetFirstFocusableElement()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetLastFocusableElement( CDependencyObject * pSearchStart, CDependencyObject * * ppLastFocusable )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasFrameworkCallbacks_GetLastFocusableElement()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBox_AttachDeleteButtonClickHandler( CDependencyObject * nativeTextBox )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBox_AttachDeleteButtonClickHandler()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_EnableScrollViewerIntegration( CDependencyObject *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_EnableScrollViewerIntegration()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_GetViewportSize( CDependencyObject *, XFLOAT *, XFLOAT * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_GetViewportSize()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_TextWrappingChanged( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_TextWrappingChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_ClipboardElement( CDependencyObject *, XUINT32, CDependencyObject *, XUINT32, XUINT32, CValue * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_ClipboardElement()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_ClipboardString( CDependencyObject *, unsigned short *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_ClipboardString()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichTextBox_ClipboardEnd( CDependencyObject *, unsigned short * *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichTextBox_ClipboardEnd()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::RichEditBox_HandleHyperlinkNavigation( unsigned short *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasRichEditBox_HandleHyperlinkNavigation()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBoxView_CaretChanged( CDependencyObject * pNativeTextBoxView )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBoxView_CaretChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBoxView_CaretVisibilityChanged( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBoxView_CaretVisibilityChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::TextBoxView_InvalidateView( CDependencyObject * pNativeTextBoxView )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasTextBoxView_InvalidateView()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::PasswordBox_AttachRevealButtonListener( CDependencyObject * nativePasswordBox )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasPasswordBox_AttachRevealButtonListener()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsControl_SetItemCollection( CItemCollection *, CItemsControl * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemsControl_SetItemCollection()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsControl_ClearVisualChildren( CItemsControl *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemsControl_ClearVisualChildren()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsControl_DisplayMemberPathChanged( CItemsControl * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemsControl_DisplayMemberPathChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsControl_RecreateVisualChildren( CItemsControl * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemsControl_RecreateVisualChildren()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsControl_NotifyAllItemsAdded( CItemsControl * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemsControl_NotifyAllItemsAdded()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemsPresenter_Dispose( CItemsPresenter * pNativeItemsPresenter )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasItemsPresenter_Dispose()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ContentControl_OnContentChanged( CDependencyObject *, CValue *, CValue * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasContentControl_OnContentChanged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ContentPresenter_GetContentType( CDependencyObject *, void * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasContentPresenter_GetContentType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DisplayMemberTemplate_BindText( CDisplayMemberTemplate *, CTextBlock * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDisplayMemberTemplate_BindText()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Popup_AddManagedPeerReference( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasPopup_AddManagedPeerReference()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Popup_RemoveManagedPeerReference( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasPopup_RemoveManagedPeerReference()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Effect_MapRect( CDependencyObject *, struct XRECTF_WH *, struct XRECTF_WH * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEffect_MapRect()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Effect_MapRectInverse( CDependencyObject *, struct XRECTF_WH *, struct XRECTF_WH * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEffect_MapRectInverse()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Effect_GetEffectMapping( CDependencyObject *, CTransform * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEffect_GetEffectMapping()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Effect_MapPoint( CDependencyObject *, struct XPOINTF *, struct XPOINTF * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEffect_MapPoint()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Effect_MapPointInverse( CDependencyObject *, struct XPOINTF *, struct XPOINTF * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasEffect_MapPointInverse()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_FireEvent( CDependencyObject *, CDependencyObject *, int, int, unsigned short *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_FireEvent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_RaiseEvent( CDependencyObject *, XUINT32, CDependencyObject *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_RaiseEvent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_PopulateDragEventArgs( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_PopulateDragEventArgs()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_GetResourceFromAssembly( unsigned short *, CValue *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_GetResourceFromAssembly()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_TriggerGCCollect()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_TriggerGCCollect()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_LoadAssemblyFromFilePath( unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_LoadAssemblyFromFilePath()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_LoadAssembly( unsigned short *, void *, int, void *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_LoadAssembly()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::JoltHelper_SetCulture( unsigned short *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasJoltHelper_SetCulture()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Error_ClearException()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasError_ClearException()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Error_GetExceptionText( unsigned short * *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasError_GetExceptionText()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Error_CallAUEHandler( XUINT32 hr )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasError_CallAUEHandler()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CreateUnknownObject( unsigned short *, unsigned short *, void *, unsigned short *, XUINT32 *, XUINT32 *, XUINT32 *, void * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CreateUnknownObject()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CreateKnownObject( void *, XUINT32, unsigned short *, void * *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CreateKnownObject()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CreateWrapperObject( void *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CreateWrapperObject()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_InvalidateProperty( CDependencyObject *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_InvalidateProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetPropertyAttribute( void *, unsigned short *, unsigned short *, unsigned short *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetPropertyAttribute()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetEventAttribute( void * nativeRoot, void * nativeTarget, unsigned short * attrName, unsigned short * attrValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetEventAttribute()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetBindingForObject( void * nativeTarget, unsigned short * propertyName, XUINT32 nKnownIndex, void * nativeBinding, unsigned short * attachedDPOwnerNamespace, unsigned short * attachedDPOwnerAssembly )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetBindingForObject()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_InvalidateStyleBinding( CDependencyObject *, unsigned short *, XUINT32, XUINT32, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_InvalidateStyleBinding()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetRelativeSource( CDependencyObject *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetRelativeSource()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetTemplateBinding( CDependencyObject * source, struct XamlPropertyToken tokSourceProperty, CDependencyObject * target, struct XamlPropertyToken tokTargetProperty )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetTemplateBinding()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ResolveTypeName( unsigned short *, void *, unsigned short *, XUINT32, unsigned short * *, XUINT32 *, XUINT32 *, XUINT32 *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ResolveTypeName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_EnsureIsObjectOfType( void * target, void * targetType )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_EnsureIsObjectOfType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_TypeIsAssignableFrom( XUINT32 baseTypeId, XUINT32 derivedTypeId )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_TypeIsAssignableFrom()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCustomTypeIDFromObject( CDependencyObject *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCustomTypeIDFromObject()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCustomTypeFullName( CDependencyObject * target, unsigned short * * fullName, XUINT32 * fullNameLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCustomTypeFullName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_AreObjectsOfSameType( CDependencyObject *, CDependencyObject *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_AreObjectsOfSameType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetBaseType( CDependencyObject *, void * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetBaseType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCustomPropertyID( XUINT32 typeID, unsigned short * propertyName, XUINT32 * customPropertyID )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCustomPropertyID()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetCustomProperty( CDependencyObject * nativeTarget, XUINT32 customPropertyID, CValue * propertyValue, XUINT32 typeIndex )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetCustomProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_HasManagedNameProperty( CDependencyObject *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_HasManagedNameProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCustomProperty( CDependencyObject * nativeTarget, XUINT32 customPropertyID, CValue * propertyValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCustomProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCustomPropertyType( XUINT32 customPropertyID, XUINT32 * typeIndex )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCustomPropertyType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetAnimatedValue( CDependencyObject * nativeTarget, XUINT32 customPropertyID, CValue * propertyValue, XUINT32 typeIndex )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetAnimatedValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ClearAnimatedValue( CDependencyObject * nativeTarget, XUINT32 customPropertyID, XBOOL HasHoldEndValue, CValue * holdEndValue, XUINT32 typeIndex )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ClearAnimatedValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetDataContext( CFrameworkElement * pElement, CValue * pValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetDataContext()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ClearDataContext( CFrameworkElement * pElement )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ClearDataContext()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetContent( CDependencyObject * nativeTarget, CValue * propertyValue, int typeIndex )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetContent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CreateBindingExtension( XCHAR * , CDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CreateBindingExtension()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetTypeFlags( CDependencyObject *, XUINT32, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetTypeFlags()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SupportInitializeEndInit( CDependencyObject * nativeTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SupportInitializeEndInit()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetRootAssemblyName( void * rootObjectPtr, XCHAR * * assemblyName, XUINT32 * assemblyNameLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetRootAssemblyName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CheckPeerType( CDependencyObject * nativeRoot, XCHAR * peerType, int bCheckExact )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CheckPeerType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ManagedPeerTreeUpdate( CDependencyObject * oldParentElement, CDependencyObject * parentElement, CDependencyObject * childElement, XUINT8 bIsParentAlive, XUINT8 bKeepReferenceToParent, XUINT32 canCreateParent )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ManagedPeerTreeUpdate()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_CreateManagedPeer( CDependencyObject *, int, XUINT32, XUINT32, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_CreateManagedPeer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_UnpegManagedPeerNoRef( CDependencyObject * element )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_UnpegManagedPeerNoRef()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_PegManagedPeerNoRef( CDependencyObject * element )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_PegManagedPeerNoRef()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ShutdownAllPeers()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ShutdownAllPeers()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_SetTemplateEventRoot( CDependencyObject *, CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_SetTemplateEventRoot()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetTemplateEventRoot( CDependencyObject *, CDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetTemplateEventRoot()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ProcessMarkupExtension( CDependencyObject *, XUINT32, unsigned short *, CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ProcessMarkupExtension()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_IsCustomEvent( CDependencyObject *, unsigned short *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_IsCustomEvent()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_IsoStorageIncreaseQuotaTo( __int64 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_IsoStorageIncreaseQuotaTo()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_NavigationHelper_Navigate( CDependencyObject *, unsigned short *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_NavigationHelper_Navigate()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_Hyperlink_OnClick( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_Hyperlink_OnClick()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_IsWellFormedUriString( unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_IsWellFormedUriString()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_GetCollectionForDependencyObjectCollection( CDependencyObject * nativeDO, CDependencyObject * * nativeCollection )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_GetCollectionForDependencyObjectCollection()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_ResolveFileResource( unsigned short * path, unsigned short * * fileName )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_ResolveFileResource()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::FrameworkCallbacks_LoadThemeResources()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasFrameworkCallbacks_LoadThemeResources()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::InternalWebRequest_WebRequest_CompletedCallback( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasInternalWebRequest_WebRequest_CompletedCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::InternalWebRequest_WebRequest_FailedCallback( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasInternalWebRequest_WebRequest_FailedCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::InternalWebRequest_WebRequest_ProgressCallback( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasInternalWebRequest_WebRequest_ProgressCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::InternalWebRequest_WebRequest_UploadProgressCallback( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasInternalWebRequest_WebRequest_UploadProgressCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedPeerTable_TryPegManagedPeer( CDependencyObject *, XUINT32, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedPeerTable_TryPegManagedPeer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedPeerTable_TryUnpegManagedPeer( CDependencyObject * element, XUINT32 isShutdownException, XUINT32 * pWasUnpegged )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedPeerTable_TryUnpegManagedPeer()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_Initialize()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_Initialize()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_ResolveAssembly( unsigned short * inAssemblyName, XUINT32 * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_ResolveAssembly()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTypeNamespace( unsigned short * inAssemblyName, unsigned short * inTypeNamespace, struct XamlTypeNamespaceToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTypeNamespace()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTypeNamespaceForType( struct XamlTypeToken sTypeToken, unsigned short * * retName, XUINT32 * retNameLength, struct XamlTypeNamespaceToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTypeNamespaceForType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_LookupTypeFlags( struct XamlTypeToken sTypeToken, XamlBitSet<enum BoolTypeBits> btbLookupValues, XamlBitSet<enum BoolTypeBits> * btbBitsChecked, XamlBitSet<enum BoolTypeBits> * btbReturnValues )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_LookupTypeFlags()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_LookupPropertyFlags( struct XamlPropertyToken sPropertyToken, XamlBitSet<enum BoolPropertyBits> bpbLookupValues, XamlBitSet<enum BoolPropertyBits> * bpbBitsChecked, XamlBitSet<enum BoolPropertyBits> * bpbReturnValues )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_LookupPropertyFlags()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_ResolveTypeName( struct XamlTypeNamespaceToken inNamespaceToken, unsigned short * inTypeName, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_ResolveTypeName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_ResolvePropertyName( struct XamlTypeToken sTypeToken, unsigned short * inPropertyName, struct XamlPropertyToken * outProperty, struct XamlTypeToken * outPropertyTypeToken )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_ResolvePropertyName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_ResolveDependencyPropertyName( struct XamlTypeToken sTypeToken, unsigned short * inPropertyName, struct XamlPropertyToken * outProperty, struct XamlTypeToken * outPropertyTypeToken )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_ResolveDependencyPropertyName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTypeName( struct XamlTypeToken sTypeToken, unsigned short * * retName, XUINT32 * retNameLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTypeName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTypeFullName( struct XamlTypeToken sTypeToken, unsigned short * * retName, XUINT32 * retNameLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTypeFullName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetPropertyName( struct XamlPropertyToken sPropertyToken, unsigned short * * retName, XUINT32 * retNameLength )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetPropertyName()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetBaseType( struct XamlTypeToken sTypeToken, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetBaseType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetDeclaringType( struct XamlPropertyToken sPropertyToken, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetDeclaringType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_IsAssignableFrom( struct XamlTypeToken sDerivedTypeToken, struct XamlTypeToken rxtBaseType, XUINT32 * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_IsAssignableFrom()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetContentProperty( struct XamlTypeToken sTypeToken, struct XamlPropertyToken * rPropertyToken, struct XamlTypeToken * rContentPropertyTypeToken )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetContentProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetCollectionItemType( struct XamlTypeToken sCollectionTypeToken, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetCollectionItemType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTextSyntaxForType( struct XamlTypeToken sTypeToken, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTextSyntaxForType()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ManagedTypeInfoProviderRPInvokes_GetTextSyntaxForProperty( struct XamlPropertyToken sPropertyToken, struct XamlTypeToken * retValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasManagedTypeInfoProviderRPInvokes_GetTextSyntaxForProperty()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HwndHost_BuildWindow( CDependencyObject *, void *, void * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasHwndHost_BuildWindow()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HwndHost_DestroyWindow( CDependencyObject * nativeHwndHost )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasHwndHost_DestroyWindow()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HwndHost_TranslateAccelerator( CDependencyObject *, void *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasHwndHost_TranslateAccelerator()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XcpImports_ParticipateInTransition( CDependencyObject *, CDependencyObject *, int, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXcpImports_ParticipateInTransition()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XcpImports_CreateStoryboardsForTransition( CDependencyObject *, CDependencyObject *, struct XRECTF_WH, struct XRECTF_WH, int, int *, CStoryboard * *, int * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXcpImports_CreateStoryboardsForTransition()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XcpImports_StaggerManaged( CDependencyObject *, int, CUIElement * *, struct XRECTF_WH *, XFLOAT * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXcpImports_StaggerManaged()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XcpImports_GetDynamicTimelines( CDependencyObject * nativeDynamicTimeline, XUINT32 bGenerateSteadyStateOnly, CValue * timelineCollection )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXcpImports_GetDynamicTimelines()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XcpImports_PerFrameCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXcpImports_PerFrameCallback()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerStringValue( CDependencyObject *, enum UIAXcp::APAutomationProperties, unsigned short *, int * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerStringValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerIntValue( CDependencyObject *, enum UIAXcp::APAutomationProperties, int * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerIntValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerPointValue( CDependencyObject *, enum UIAXcp::APAutomationProperties, struct XPOINTF * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerPointValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerRectValue( CDependencyObject *, enum UIAXcp::APAutomationProperties, struct XRECTF_WH * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerRectValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerAPValue( CDependencyObject *, enum UIAXcp::APAutomationProperties, struct IDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerAPValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_CallAutomationPeerMethod( CDependencyObject *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_CallAutomationPeerMethod()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerChildren( CDependencyObject *, XUINT32, int *, struct IDependencyObject * * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerChildren()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetAutomationPeerAPValueFromPoint( CDependencyObject * nativeTarget, CValue param, CDependencyObject * * ppReturnAP )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetAutomationPeerAPValueFromPoint()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GetPattern( CDependencyObject * nativeTarget, CDependencyObject * * nativeInterface, enum UIAXcp::APPatternInterface eInterface )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GetPattern()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_UIATextRangeInvoke( CDependencyObject * nativeTarget, int eFunction, int cParams, void * pvParams, CValue * pRetVal )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_UIATextRangeInvoke()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_UIAPatternInvoke( CDependencyObject * nativeTarget, enum UIAXcp::APPatternInterface eInterface, int eFunction, int cParams, void * pvParams, CValue * pRetVal )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_UIAPatternInvoke()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_NotifyNoUIAClientObjectForAP( CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_NotifyNoUIAClientObjectForAP()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::AutomationPeer_GenerateAutomationPeerEventsSource( CDependencyObject *, CDependencyObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasAutomationPeer_GenerateAutomationPeerEventsSource()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ItemContainerGenerator_ExecuteDeferredUnlink( CUIElement * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasItemContainerGenerator_ExecuteDeferredUnlink()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::VisualStates_ChangeControlVisualState( CDependencyObject *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasVisualStates_ChangeControlVisualState()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::LicenseAcquirer_AbortComplete( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasLicenseAcquirer_AbortComplete()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::LicenseAcquirer_DomainJoinRequired( void *, unsigned short *, struct XGUID *, struct XGUID *, unsigned short * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasLicenseAcquirer_DomainJoinRequired()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::LicenseAcquirer_Complete( void *, unsigned short *, XUINT32, void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasLicenseAcquirer_Complete()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::LicenseAcquirer_ChallengeGenerated( void *, struct IPALMemory *, XUINT32, unsigned short *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasLicenseAcquirer_ChallengeGenerated()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_OpenMedia( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_OpenMedia()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_CloseMedia( void * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_CloseMedia()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_Seek( void *, __int64 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_Seek()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_GetSample( void *, enum MediaStreamType )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_GetSample()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_SetPlaybackRate( void *, XFLOAT )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_SetPlaybackRate()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_GetDiagnostic( void *, enum MediaStreamSourceDiagnosticKind )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_GetDiagnostic()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_SwitchMediaStream( void *, int )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_SwitchMediaStream()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_GetAudioBufferLength( void *, int * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_GetAudioBufferLength()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_DrmSetupDecryptorCompleted( void *, struct XGUID *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_DrmSetupDecryptorCompleted()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MediaStreamSource_DrmDecryptorInvalidated( void *, struct IPALMemory *, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMediaStreamSource_DrmDecryptorInvalidated()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DomainAcquirer_AbortComplete( void *, struct XGUID *, struct XGUID *, XUINT32, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDomainAcquirer_AbortComplete()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DomainAcquirer_ChallengeGenerated( void *, struct IPALMemory *, XUINT32, unsigned short *, XUINT32, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDomainAcquirer_ChallengeGenerated()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::DomainAcquirer_Complete( void *, struct XGUID *, struct XGUID *, unsigned short *, XUINT32, XUINT32 )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasDomainAcquirer_Complete()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MultiScaleTileSource_GetTileLayerData( CDependencyObject *, int, int, int, int, unsigned short * *, XUINT32 *, CWriteableBitmap * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMultiScaleTileSource_GetTileLayerData()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MultiScaleTileSource_GetTileLayerCount( CDependencyObject *, XUINT32, XUINT32, XUINT32, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMultiScaleTileSource_GetTileLayerCount()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MultiScaleTileSource_GetMSITileSourceInitParams( CDependencyObject *, XUINT32 *, XUINT32 *, XUINT32 *, XUINT32 *, XUINT32 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMultiScaleTileSource_GetMSITileSourceInitParams()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::MultiScaleTileSource_GetMaxTileBlendTime( CDependencyObject *, __int64 * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasMultiScaleTileSource_GetMaxTileBlendTime()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ResourceDictionary_UpdateResource( CDependencyObject *, XUINT32, unsigned short *, CDependencyObject *, CDependencyObject * * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasResourceDictionary_UpdateResource()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_CreateInstance( struct XamlTypeToken inXamlType, struct XamlQualifiedObject * newObject )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_CreateInstance()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_CreateFromValue( void * inServiceContext, struct XamlTypeToken inTs, struct XamlQualifiedObject * qoValue, struct XamlPropertyToken inProperty, struct XamlTypeToken inType, struct XamlQualifiedObject * qoRootInstance, struct XamlQualifiedObject * qo )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_CreateFromValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_CreateFromXmlText( struct XamlTypeToken, unsigned short *, struct XamlQualifiedObject * )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_CreateFromXmlText()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_GetValue( struct XamlQualifiedObject * qoObj, struct XamlPropertyToken inProperty, struct XamlQualifiedObject * outValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_GetValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_SetValue( struct XamlTypeToken inType, struct XamlQualifiedObject * inObj, struct XamlPropertyToken inProperty, struct XamlQualifiedObject * inValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_SetValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_Add( struct XamlQualifiedObject * qoCollection, struct XamlPropertyToken inCollectionProperty, struct XamlQualifiedObject * inValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_Add()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_AddToDictionary( struct XamlQualifiedObject * dictionary, struct XamlPropertyToken property, struct XamlQualifiedObject * inKey, struct XamlQualifiedObject * inValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_AddToDictionary()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_CallProvideValue( struct XamlQualifiedObject * markupExtension, void * pspXamlCommonServiceProviderContext, struct XamlQualifiedObject * outValue )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_CallProvideValue()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlManagedRuntimeRPInvokes_SetConnectionId( struct XamlQualifiedObject * qoComponentConnector, struct XamlQualifiedObject * qoConnectionId, struct XamlQualifiedObject * qoTarget )
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlManagedRuntimeRPInvokes_SetConnectionId()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::XamlSchemaContext_EnsureManagedAssemblyAttributesLoaded()
{
	throw std::logic_error("The method or operation is not implemented.");
}

XBOOL CFxCallbacks::HasXamlSchemaContext_EnsureManagedAssemblyAttributesLoaded()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ApplicationBarService_GetBottomAppBarStatus( XUINT32 * pbIsOpen, XUINT32 * pbIsSticky, XFLOAT * pWidth, XFLOAT * pHeight )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasApplicationBarService_GetBottomAppBarStatus()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::ApplicationBarService_ProcessToggleApplicationBarsFromMouseRightTapped()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasApplicationBarService_ProcessToggleApplicationBarsFromMouseRightTapped()
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::Window_GetCoreWindowBounds( struct XRECTF_WH * pCoreWindowBounds )
{
	throw std::logic_error("The method or operation is not implemented.");
}

HRESULT CFxCallbacks::HasWindow_GetCoreWindowBounds()
{
	throw std::logic_error("The method or operation is not implemented.");
}

